// // // // // // // // // // // // #include <stdio.h>

// // // // // // // // // // // // void getnet()
// // // // // // // // // // // // {
    
// // // // // // // // // // // // }

// // // // // // // // // // // // void chushihua(char zu[4][4],int k)//初始化
// // // // // // // // // // // // {
// // // // // // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // // // // // //     {
// // // // // // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // // // // // //         {
// // // // // // // // // // // //             zu[i][j]='Q';
// // // // // // // // // // // //         }
// // // // // // // // // // // //     }
// // // // // // // // // // // // }


// // // // // // // // // // // // void jieshou(char zu[4][4],int k)//输入网格
// // // // // // // // // // // // {
// // // // // // // // // // // //     char l;
// // // // // // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // // // // // //     {
// // // // // // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // // // // // //         {
// // // // // // // // // // // //             l=getchar();
// // // // // // // // // // // //             zu[i][j]=l;
// // // // // // // // // // // //         }
// // // // // // // // // // // //         l=getchar();
// // // // // // // // // // // //     }
// // // // // // // // // // // // }

// // // // // // // // // // // // void printzu(char zu[4][4],int k)//输出网格
// // // // // // // // // // // // {
// // // // // // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // // // // // //     {
// // // // // // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // // // // // //         {
// // // // // // // // // // // //             printf("%c",zu[i][j]) ;
// // // // // // // // // // // //         }
// // // // // // // // // // // //         printf("\n");
// // // // // // // // // // // //     }
// // // // // // // // // // // // }

// // // // // // // // // // // // void fangzhi(char zu[4][4],int k)//放置炮台
// // // // // // // // // // // // {
// // // // // // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // // // // // //     {
// // // // // // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // // // // // //         {
// // // // // // // // // // // //             if(zu[i][j]=='X')
// // // // // // // // // // // //             {
// // // // // // // // // // // //                 if(zu[i+1][j]=='.')
// // // // // // // // // // // //                 {
// // // // // // // // // // // //                     zu[i+1][j]='+';
// // // // // // // // // // // //                 }
// // // // // // // // // // // //                 if(zu[i][j+1]=='.')
// // // // // // // // // // // //                 {
// // // // // // // // // // // //                     zu[i][j+1]='+';
// // // // // // // // // // // //                 }
// // // // // // // // // // // //                 if(zu[i-1][j]=='.')
// // // // // // // // // // // //                 {
// // // // // // // // // // // //                     zu[i-1][j]='+';
// // // // // // // // // // // //                 }
// // // // // // // // // // // //                 if(zu[i][j-1]=='.')
// // // // // // // // // // // //                 {
// // // // // // // // // // // //                     zu[i][j-1]='+';
// // // // // // // // // // // //                 }
// // // // // // // // // // // //             }
// // // // // // // // // // // //         }
// // // // // // // // // // // //     }
// // // // // // // // // // // // }


// // // // // // // // // // // // void destory(int a,int b,char arr[4][4])
// // // // // // // // // // // // {
// // // // // // // // // // // //     for(int i=0;i<4;i++)//横向检测
// // // // // // // // // // // //     {
// // // // // // // // // // // //         if(arr[a+i][b]=='X'||arr[a+i][b]=='Q')
// // // // // // // // // // // //         {
// // // // // // // // // // // //             break;
// // // // // // // // // // // //         }
// // // // // // // // // // // //         else
// // // // // // // // // // // //         {
// // // // // // // // // // // //             arr[a+i][b]='D';
// // // // // // // // // // // //         }
// // // // // // // // // // // //     }
// // // // // // // // // // // //     for(int i=0;i<4;i++)//纵向检测
// // // // // // // // // // // //     {
// // // // // // // // // // // //         if(arr[a][b+i]=='X'||arr[a][b+i]=='Q')
// // // // // // // // // // // //         {
// // // // // // // // // // // //             break;
// // // // // // // // // // // //         }
// // // // // // // // // // // //         else
// // // // // // // // // // // //         {
// // // // // // // // // // // //             arr[a][b+i]='D';
// // // // // // // // // // // //         }
// // // // // // // // // // // //     }
// // // // // // // // // // // // }

// // // // // // // // // // // // void destory_tr(char arr[4][4],int k)
// // // // // // // // // // // // {
// // // // // // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // // // // // //     {
// // // // // // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // // // // // //         {
// // // // // // // // // // // //             if(arr[i][j]=='+')
// // // // // // // // // // // //             {
// // // // // // // // // // // //                 destory(i,j,arr);
// // // // // // // // // // // //             }
// // // // // // // // // // // //         }
// // // // // // // // // // // //     }
// // // // // // // // // // // // }


// // // // // // // // // // // // int main ()
// // // // // // // // // // // // {
// // // // // // // // // // // //     char s;
// // // // // // // // // // // //     char net[4][4]={};
// // // // // // // // // // // //     int k;
// // // // // // // // // // // //     scanf("%d",&k);//选择网格大小
// // // // // // // // // // // //     chushihua(net,4);//初始化函数
// // // // // // // // // // // //     while(k!=0)
// // // // // // // // // // // //     {
// // // // // // // // // // // //         s=getchar();
// // // // // // // // // // // //         jieshou(net,k);//输入网格
// // // // // // // // // // // //         printf("\n");                    //测试用的函数
// // // // // // // // // // // //         fangzhi(net,k);//放置炮台
        
// // // // // // // // // // // //         destory_tr(net,k);//摧毁炮台和街道
// // // // // // // // // // // //         printzu(net,4);//输出网格                    //测试用的函数
// // // // // // // // // // // //         scanf("%d",&k);//选择网格大小
// // // // // // // // // // // //         chushihua(net,4);//初始化函数
// // // // // // // // // // // //     }
    
// // // // // // // // // // // //     return 0;
// // // // // // // // // // // // }













// // // // // // // // // // // #include <stdio.h>

// // // // // // // // // // // void getnet()
// // // // // // // // // // // {
    
// // // // // // // // // // // }

// // // // // // // // // // // void chushihua(char zu[4][4],int k)//初始化
// // // // // // // // // // // {
// // // // // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // // // // //     {
// // // // // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // // // // //         {
// // // // // // // // // // //             zu[i][j]='Q';
// // // // // // // // // // //         }
// // // // // // // // // // //     }
// // // // // // // // // // // }


// // // // // // // // // // // void jieshou(char zu[4][4],int k)//输入网格
// // // // // // // // // // // {
// // // // // // // // // // //     char l;
// // // // // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // // // // //     {
// // // // // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // // // // //         {
// // // // // // // // // // //             l=getchar();
// // // // // // // // // // //             zu[i][j]=l;
// // // // // // // // // // //         }
// // // // // // // // // // //         l=getchar();
// // // // // // // // // // //     }
// // // // // // // // // // // }

// // // // // // // // // // // void printzu(char zu[4][4],int k)//输出网格
// // // // // // // // // // // {
// // // // // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // // // // //     {
// // // // // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // // // // //         {
// // // // // // // // // // //             printf("%c",zu[i][j]) ;
// // // // // // // // // // //         }
// // // // // // // // // // //         printf("\n");
// // // // // // // // // // //     }
// // // // // // // // // // // }

// // // // // // // // // // // void fangzhi(char zu[4][4],int k)//放置炮台
// // // // // // // // // // // {
// // // // // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // // // // //     {
// // // // // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // // // // //         {
// // // // // // // // // // //             if(zu[i][j]=='X')
// // // // // // // // // // //             {
// // // // // // // // // // //                 if(zu[i+1][j]=='.')
// // // // // // // // // // //                 {
// // // // // // // // // // //                     zu[i+1][j]='+';
// // // // // // // // // // //                 }
// // // // // // // // // // //                 if(zu[i][j+1]=='.')
// // // // // // // // // // //                 {
// // // // // // // // // // //                     zu[i][j+1]='+';
// // // // // // // // // // //                 }
// // // // // // // // // // //                 if(zu[i-1][j]=='.')
// // // // // // // // // // //                 {
// // // // // // // // // // //                     zu[i-1][j]='+';
// // // // // // // // // // //                 }
// // // // // // // // // // //                 if(zu[i][j-1]=='.')
// // // // // // // // // // //                 {
// // // // // // // // // // //                     zu[i][j-1]='+';
// // // // // // // // // // //                 }
// // // // // // // // // // //             }
// // // // // // // // // // //         }
// // // // // // // // // // //     }
// // // // // // // // // // // }


// // // // // // // // // // // // void destory(int a,int b,char arr[4][4])
// // // // // // // // // // // // {
// // // // // // // // // // // //     for(int i=0;i<4;i++)//纵向检测
// // // // // // // // // // // //     {
// // // // // // // // // // // //         if(arr[a+i][b]=='X'||arr[a+i][b]=='Q')
// // // // // // // // // // // //         {
// // // // // // // // // // // //             break;
// // // // // // // // // // // //         }
// // // // // // // // // // // //         else
// // // // // // // // // // // //         {
// // // // // // // // // // // //             arr[a+i][b]='D';
// // // // // // // // // // // //         }
// // // // // // // // // // // //     }
// // // // // // // // // // // //     for(int i=0;i<4;i++)//横向检测
// // // // // // // // // // // //     {
// // // // // // // // // // // //         if(arr[a][b+i]=='X'||arr[a][b+i]=='Q')
// // // // // // // // // // // //         {
// // // // // // // // // // // //             break;
// // // // // // // // // // // //         }
// // // // // // // // // // // //         else
// // // // // // // // // // // //         {
// // // // // // // // // // // //             arr[a][b+i]='D';
// // // // // // // // // // // //         }
// // // // // // // // // // // //     }
// // // // // // // // // // // // }

// // // // // // // // // // // void destory_tr(char arr[4][4],int k)
// // // // // // // // // // // {
// // // // // // // // // // //     for(int a=0;a<4;a++)
// // // // // // // // // // //     {
// // // // // // // // // // //         for(int b=0;b<4;b++)
// // // // // // // // // // //         {
// // // // // // // // // // //             if(arr[a][b]=='+')
// // // // // // // // // // //             {
// // // // // // // // // // //                 for(int i=0;i<4;i++)//纵向检测
// // // // // // // // // // //                     {
// // // // // // // // // // //                         if(arr[a+i][b]=='X'||arr[a+i][b]=='Q')
// // // // // // // // // // //                         {
// // // // // // // // // // //                             break;
// // // // // // // // // // //                         }
// // // // // // // // // // //                         else
// // // // // // // // // // //                         {
// // // // // // // // // // //                             arr[a+i][b]='D';
// // // // // // // // // // //                         }
// // // // // // // // // // //                     }
// // // // // // // // // // //                 for(int j=0;j<4;j++)//横向检测
// // // // // // // // // // //                     {
// // // // // // // // // // //                         if(arr[a][b+j]=='X'||arr[a][b+j]=='Q')
// // // // // // // // // // //                         {
// // // // // // // // // // //                             break;
// // // // // // // // // // //                         }
// // // // // // // // // // //                         else
// // // // // // // // // // //                         {
// // // // // // // // // // //                             arr[a][b+j]='D';
// // // // // // // // // // //                         }
// // // // // // // // // // //                     }
// // // // // // // // // // //             }
// // // // // // // // // // //         }
// // // // // // // // // // //     }
// // // // // // // // // // // }


// // // // // // // // // // // int main ()
// // // // // // // // // // // {
// // // // // // // // // // //     char s;
// // // // // // // // // // //     char net[4][4]={};
// // // // // // // // // // //     int k;
// // // // // // // // // // //     scanf("%d",&k);//选择网格大小
// // // // // // // // // // //     chushihua(net,4);//初始化函数
// // // // // // // // // // //     while(k!=0)
// // // // // // // // // // //     {
// // // // // // // // // // //         s=getchar();
// // // // // // // // // // //         jieshou(net,k);//输入网格
// // // // // // // // // // //         printf("\n");                    //测试用的函数
// // // // // // // // // // //         fangzhi(net,k);//放置炮台
// // // // // // // // // // //         destory_tr(net,k);//摧毁炮台和街道
// // // // // // // // // // //         printzu(net,4);//输出网格                    //测试用的函数
// // // // // // // // // // //         scanf("%d",&k);//选择网格大小
// // // // // // // // // // //         chushihua(net,4);//初始化函数
// // // // // // // // // // //     }
    
// // // // // // // // // // //     return 0;
// // // // // // // // // // // }

// // // // // // // // // // #include<stdio.h>
// // // // // // // // // // int n;
// // // // // // // // // // char map[4][4];
// // // // // // // // // // int bestn;//标识符，标记放过炮塔的位置





// // // // // // // // // // int canput(int x, int y)
// // // // // // // // // // {
// // // // // // // // // //     int i;
// // // // // // // // // //     for (i = x - 1;i >= 0;i--)
// // // // // // // // // //     {
// // // // // // // // // //         if (map[i][y] == 'X')
// // // // // // // // // //         {
// // // // // // // // // //             break;
// // // // // // // // // //         }
// // // // // // // // // //         if (map[i][y] == 'o')
// // // // // // // // // //         {
            
// // // // // // // // // //             return 0;
// // // // // // // // // //         }
// // // // // // // // // //     }
// // // // // // // // // //     for (i = y - 1;i >= 0;i--)
// // // // // // // // // //     {
// // // // // // // // // //         if (map[x][i] == 'X')
// // // // // // // // // //         {
// // // // // // // // // //             break;//wall直接退出判断
// // // // // // // // // //         }
// // // // // // // // // //         if (map[x][i] == 'o')
// // // // // // // // // //         {
            
// // // // // // // // // //             return 0;//为假结束判断
// // // // // // // // // //         }
// // // // // // // // // //     }
   
// // // // // // // // // //     return 1;//为真结束判断
// // // // // // // // // // }
// // // // // // // // // // //K表示放置炮塔的位置 
// // // // // // // // // // void backtrack(int k, int current)
// // // // // // // // // // {
// // // // // // // // // //     int x, y;
// // // // // // // // // //     if (k >= n * n)//k设置在1--n*n之间
// // // // // // // // // //     {
// // // // // // // // // //         if (current > bestn)
// // // // // // // // // //         {
// // // // // // // // // //             bestn = current;//赋予最大值
// // // // // // // // // //         }
        
// // // // // // // // // //         return;
// // // // // // // // // //     }
// // // // // // // // // //     else
// // // // // // // // // //     {
// // // // // // // // // //         x = k / n;//横向坐标每n个是相同的
// // // // // // // // // //         y = k % n;//纵向坐标每n个为一组
// // // // // // // // // //         if (map[x][y] == '.' && canput(x, y))//如果return 1 则继续执行if语句
// // // // // // // // // //         {
// // // // // // // // // //             map[x][y] = 'o';
// // // // // // // // // //             backtrack(k + 1, current + 1);//执行顺序为（0，1）（0，2）....
// // // // // // // // // //             map[x][y] = '.';
// // // // // // // // // //         }
// // // // // // // // // //         backtrack(k + 1, current);
// // // // // // // // // //     }
// // // // // // // // // // }
// // // // // // // // // // int main()
// // // // // // // // // // {
// // // // // // // // // //     while (scanf("%d", &n) != EOF)
// // // // // // // // // //     {
// // // // // // // // // //         int i, j;
// // // // // // // // // //         bestn = 0;
// // // // // // // // // //         for (i = 0;i < n;i++)
// // // // // // // // // //         {
// // // // // // // // // //             for (j = 0;j < n;j++)
// // // // // // // // // //             {
// // // // // // // // // //                 char ch;
// // // // // // // // // //                 ch = getchar();
// // // // // // // // // //                 if (ch == '\n')
// // // // // // // // // //                 {
// // // // // // // // // //                     j--;
// // // // // // // // // //                     continue;
// // // // // // // // // //                 }
// // // // // // // // // //                 else
// // // // // // // // // //                 {
// // // // // // // // // //                     map[i][j] = ch;
// // // // // // // // // //                 } 
// // // // // // // // // //             }
// // // // // // // // // //         }
// // // // // // // // // //         backtrack(0, 0);
// // // // // // // // // //         printf("%d\n", bestn);
// // // // // // // // // //         scanf("%d", &n);
// // // // // // // // // //     }
// // // // // // // // // //     return 0;
// // // // // // // // // // }
// // // // // // // // // #include <stdio.h>
// // // // // // // // //     int k;
// // // // // // // // //     char zu[4][4];
// // // // // // // // //     int sum=0;
// // // // // // // // //     int maxsum=0;
// // // // // // // // //     char ji[4][4];
// // // // // // // // // void jilu()
// // // // // // // // // {
// // // // // // // // //     for(int i=0;i<4;i++)
// // // // // // // // //     {
// // // // // // // // //         for(int j=0;j<4;j++)
// // // // // // // // //         {
// // // // // // // // //             ji[i][j]=zu[i][j];
// // // // // // // // //         }
// // // // // // // // //     }
// // // // // // // // // }

// // // // // // // // // void huan()
// // // // // // // // // {
// // // // // // // // //     for(int i=0;i<4;i++)
// // // // // // // // //     {
// // // // // // // // //         for(int j=0;j<4;j++)
// // // // // // // // //         {
// // // // // // // // //             zu[i][j]=ji[i][j];
// // // // // // // // //         }
// // // // // // // // //     }
// // // // // // // // // }

// // // // // // // // // void chushihua(int k)//初始化
// // // // // // // // // {
// // // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // // //     {
// // // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // // //         {
// // // // // // // // //             zu[i][j]='Q';
// // // // // // // // //         }
// // // // // // // // //     }
// // // // // // // // // }


// // // // // // // // // void jieshou(int k)//输入网格
// // // // // // // // // {
// // // // // // // // //     char l;
// // // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // // //     {
// // // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // // //         {
// // // // // // // // //             l=getchar();
// // // // // // // // //             zu[i][j]=l;
// // // // // // // // //         }
// // // // // // // // //         l=getchar();
// // // // // // // // //     }
// // // // // // // // // }

// // // // // // // // // void printzu(int k)//输出网格
// // // // // // // // // {
// // // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // // //     {
// // // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // // //         {
// // // // // // // // //             printf("%c",zu[i][j]) ;
// // // // // // // // //         }
// // // // // // // // //         printf("\n");
// // // // // // // // //     }
// // // // // // // // // }

// // // // // // // // // void fangzhi(int k)//放置炮台
// // // // // // // // // {
// // // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // // //     {
// // // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // // //         {
// // // // // // // // //             if(zu[i][j]=='X')
// // // // // // // // //             {
// // // // // // // // //                 if(zu[i+1][j]=='.')
// // // // // // // // //                 {
// // // // // // // // //                     zu[i+1][j]='+';
// // // // // // // // //                 }
// // // // // // // // //                 if(zu[i][j+1]=='.')
// // // // // // // // //                 {
// // // // // // // // //                     zu[i][j+1]='+';
// // // // // // // // //                 }
// // // // // // // // //                 if(zu[i-1][j]=='.')
// // // // // // // // //                 {
// // // // // // // // //                     zu[i-1][j]='+';
// // // // // // // // //                 }
// // // // // // // // //                 if(zu[i][j-1]=='.')
// // // // // // // // //                 {
// // // // // // // // //                     zu[i][j-1]='+';
// // // // // // // // //                 }
// // // // // // // // //             }
// // // // // // // // //         }
// // // // // // // // //     }
// // // // // // // // // }


// // // // // // // // // void destory(int a,int b)
// // // // // // // // // {
// // // // // // // // //     for(int i=1;i<4;i++)//纵向检测
// // // // // // // // //     {
// // // // // // // // //         if(zu[a+i][b]=='X'||zu[a+i][b]=='Q')
// // // // // // // // //         {
// // // // // // // // //             break;
// // // // // // // // //         }
// // // // // // // // //         else
// // // // // // // // //         {
// // // // // // // // //             zu[a+i][b]='D';
// // // // // // // // //         }
// // // // // // // // //     }
// // // // // // // // //     for(int i=1;i<4;i++)//横向检测
// // // // // // // // //     {
// // // // // // // // //         if(zu[a][b+i]=='X'||zu[a][b+i]=='Q')
// // // // // // // // //         {
// // // // // // // // //             break;
// // // // // // // // //         }
// // // // // // // // //         else
// // // // // // // // //         {
// // // // // // // // //             zu[a][b+i]='D';
// // // // // // // // //         }
// // // // // // // // //     }
// // // // // // // // // }

// // // // // // // // // void destory_tr(int k,int a,int b)
// // // // // // // // // {
// // // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // // //     {
// // // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // // //         {
// // // // // // // // //             if(zu[a+i][b+j]=='+')
// // // // // // // // //             {
// // // // // // // // //                 destory(a+i,b+j);
// // // // // // // // //             }
// // // // // // // // //         }
// // // // // // // // //     }
// // // // // // // // //     if (tongji(k)>maxsum)
// // // // // // // // //     {
// // // // // // // // //         maxsum=tongji(k);
// // // // // // // // //     }
// // // // // // // // // }
// // // // // // // // // void destory_hui(int k)
// // // // // // // // // {
// // // // // // // // //     for(int a=0;a<k;a++)
// // // // // // // // //     {
// // // // // // // // //         for(int b=0;b<k;b++)
// // // // // // // // //         {
// // // // // // // // //             if(zu[a][b]=='+')
// // // // // // // // //             {
// // // // // // // // //                 huan();
// // // // // // // // //                 destory_tr(k,a,b);
// // // // // // // // //             }
// // // // // // // // //         }
// // // // // // // // //     }
// // // // // // // // // }






// // // // // // // // // int tongji(int k)
// // // // // // // // // {
// // // // // // // // //     sum=0;
// // // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // // //     {
// // // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // // //         {
// // // // // // // // //             if(zu[i][j]=='+')
// // // // // // // // //             {
// // // // // // // // //                 sum++;
// // // // // // // // //             }
// // // // // // // // //         }
// // // // // // // // //     }
// // // // // // // // //     return sum;
// // // // // // // // // }


// // // // // // // // // int main ()
// // // // // // // // // {
// // // // // // // // //     char s;
// // // // // // // // //     scanf("%d",&k);//选择网格大小
// // // // // // // // //     chushihua(4);//初始化函数
// // // // // // // // //     while(k!=0)
// // // // // // // // //     {
// // // // // // // // //         s=getchar();
// // // // // // // // //         jieshou(k);//输入网格
// // // // // // // // //         // printf("\n");                    //测试用的函数
// // // // // // // // //         fangzhi(k);//放置炮台
// // // // // // // // //         jilu();
// // // // // // // // //         destory_hui(k);//摧毁炮台和街道
// // // // // // // // //         // printf("%d\n",destory_tr(k));
// // // // // // // // //         printzu(4);//输出网格                    //测试用的函数
// // // // // // // // //         scanf("%d",&k);//选择网格大小
// // // // // // // // //         chushihua(4);//初始化函数
// // // // // // // // //     }
// // // // // // // // //     return 0;
// // // // // // // // // }

// // // // // // // // #include <stdio.h>
// // // // // // // //     int k;
// // // // // // // //     char zu[4][4];
// // // // // // // //     int sum=0;
// // // // // // // //     int maxsum=0;
// // // // // // // //     char ji[4][4];
// // // // // // // //     char s;
// // // // // // // // void jilu()
// // // // // // // // {
// // // // // // // //     for(int i=0;i<4;i++)
// // // // // // // //     {
// // // // // // // //         for(int j=0;j<4;j++)
// // // // // // // //         {
// // // // // // // //             ji[i][j]=zu[i][j];
// // // // // // // //         }
// // // // // // // //     }
// // // // // // // // }

// // // // // // // // void huan()
// // // // // // // // {
// // // // // // // //     for(int i=0;i<4;i++)
// // // // // // // //     {
// // // // // // // //         for(int j=0;j<4;j++)
// // // // // // // //         {
// // // // // // // //             zu[i][j]=ji[i][j];
// // // // // // // //         }
// // // // // // // //     }
// // // // // // // // }

// // // // // // // // void chushihua(int k)//初始化
// // // // // // // // {
// // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // //     {
// // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // //         {
// // // // // // // //             zu[i][j]='Q';
// // // // // // // //         }
// // // // // // // //     }
// // // // // // // // }


// // // // // // // // void jieshou(int k)//输入网格
// // // // // // // // {
// // // // // // // //     char l;
// // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // //     {
// // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // //         {
// // // // // // // //             l=getchar();
// // // // // // // //             zu[i][j]=l;
// // // // // // // //         }
// // // // // // // //         l=getchar();
// // // // // // // //     }
// // // // // // // // }

// // // // // // // // void printzu(int k)//输出网格
// // // // // // // // {
// // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // //     {
// // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // //         {
// // // // // // // //             printf("%c",zu[i][j]) ;
// // // // // // // //         }
// // // // // // // //         printf("\n");
// // // // // // // //     }
// // // // // // // // }

// // // // // // // // void fangzhi(int k)//放置炮台
// // // // // // // // {
// // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // //     {
// // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // //         {
// // // // // // // //             if(zu[i][j]=='X')
// // // // // // // //             {
// // // // // // // //                 if(zu[i+1][j]=='.')
// // // // // // // //                 {
// // // // // // // //                     zu[i+1][j]='+';
// // // // // // // //                 }
// // // // // // // //                 if(zu[i][j+1]=='.')
// // // // // // // //                 {
// // // // // // // //                     zu[i][j+1]='+';
// // // // // // // //                 }
// // // // // // // //                 if(zu[i-1][j]=='.')
// // // // // // // //                 {
// // // // // // // //                     zu[i-1][j]='+';
// // // // // // // //                 }
// // // // // // // //                 if(zu[i][j-1]=='.')
// // // // // // // //                 {
// // // // // // // //                     zu[i][j-1]='+';
// // // // // // // //                 }
// // // // // // // //             }
// // // // // // // //         }
// // // // // // // //     }
// // // // // // // // }


// // // // // // // // void destory(int a,int b)
// // // // // // // // {
// // // // // // // //     for(int i=1;i<4;i++)//纵向检测
// // // // // // // //     {
// // // // // // // //         if(zu[a+i][b]=='X'||zu[a+i][b]=='Q')
// // // // // // // //         {
// // // // // // // //             break;
// // // // // // // //         }
// // // // // // // //         else
// // // // // // // //         {
// // // // // // // //             zu[a+i][b]='D';
// // // // // // // //         }
// // // // // // // //     }
// // // // // // // //     for(int i=1;i<4;i++)//横向检测
// // // // // // // //     {
// // // // // // // //         if(zu[a][b+i]=='X'||zu[a][b+i]=='Q')
// // // // // // // //         {
// // // // // // // //             break;
// // // // // // // //         }
// // // // // // // //         else
// // // // // // // //         {
// // // // // // // //             zu[a][b+i]='D';
// // // // // // // //         }
// // // // // // // //     }
// // // // // // // // }

// // // // // // // // int destory_tr(int k)
// // // // // // // // {
// // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // //     {
// // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // //         {
// // // // // // // //             if(zu[i][j]=='+')
// // // // // // // //             {
// // // // // // // //                 destory(i,j);
// // // // // // // //             }
// // // // // // // //         }
// // // // // // // //     }

// // // // // // // //     //
// // // // // // // //     return tongji(k);
// // // // // // // //     //
// // // // // // // //     // if (tongji(k)>maxsum)
// // // // // // // //     // {
// // // // // // // //     //     maxsum=tongji(k);
// // // // // // // //     // }
// // // // // // // // }


// // // // // // // // // void destory_hui(int k)
// // // // // // // // // {
// // // // // // // // //     for(int a=0;a<k;a++)
// // // // // // // // //     {
// // // // // // // // //         for(int b=0;b<k;b++)
// // // // // // // // //         {
// // // // // // // // //             if(zu[a][b]=='+')
// // // // // // // // //             {
// // // // // // // // //                 huan();
// // // // // // // // //                 destory_tr(k,a,b);
// // // // // // // // //             }
// // // // // // // // //         }
// // // // // // // // //     }
// // // // // // // // // }






// // // // // // // // int tongji(int k)
// // // // // // // // {
// // // // // // // //     sum=0;
// // // // // // // //     for(int i=0;i<k;i++)
// // // // // // // //     {
// // // // // // // //         for(int j=0;j<k;j++)
// // // // // // // //         {
// // // // // // // //             if(zu[i][j]=='+')
// // // // // // // //             {
// // // // // // // //                 sum++;
// // // // // // // //             }
// // // // // // // //         }
// // // // // // // //     }
// // // // // // // //     return sum;
// // // // // // // // }


// // // // // // // // // int main ()
// // // // // // // // // {
// // // // // // // // //     char s;
// // // // // // // // //     scanf("%d",&k);//选择网格大小
// // // // // // // // //     chushihua(4);//初始化函数
// // // // // // // // //     while(k!=0)
// // // // // // // // //     {
// // // // // // // // //         s=getchar();
// // // // // // // // //         jieshou(k);//输入网格
// // // // // // // // //         // printf("\n");                    //测试用的函数
// // // // // // // // //         fangzhi(k);//放置炮台
// // // // // // // // //         jilu();
// // // // // // // // //         // destory_hui(k);//摧毁炮台和街道
// // // // // // // // //         // printf("%d\n",destory_hui(k));
// // // // // // // // //         printf("%d\n",destory_tr(k));
// // // // // // // // //         // printf("%d\n",maxsum);
// // // // // // // // //         // printzu(4);//输出网格                    //测试用的函数
// // // // // // // // //         scanf("%d",&k);//选择网格大小
// // // // // // // // //         chushihua(4);//初始化函数
// // // // // // // // //     }
// // // // // // // // //     return 0;
// // // // // // // // // }


// // // // // // // // // 放置炮台
// // // // // // // // /*
// // // // // // // // q:传入的是坐标，q经过 /k 和 %k 之后可以计算出对于的坐标x和坐标y
// // // // // // // // sum传入的是当前棋盘中炮台的数量
// // // // // // // // */

// // // // // // // // void paotai(int q,int sum)
// // // // // // // // {
// // // // // // // //     int x = q / k;
// // // // // // // //     int y = q % k;
// // // // // // // //     if (zu[x][y]=='.'&&hefa)
// // // // // // // //     {
// // // // // // // //         zu[x][y]='+';//放置炮台
// // // // // // // //         paotai(q+1,sum+1);//炮台数量+1
// // // // // // // //         zu[x][y]='.';//还原
// // // // // // // //     }
    
// // // // // // // //     paotai(q+1,sum);//先写的应该是这行，传入q后面的一个位置
// // // // // // // //     if (sum>=maxsum)
// // // // // // // //     {
// // // // // // // //         maxsum=sum;
// // // // // // // //     }
    
// // // // // // // // }



// // // // // // // // // 合法性判断
// // // // // // // // /*
// // // // // // // // 如果合法就返回1，不合法返回0
// // // // // // // // */

// // // // // // // // int hefa(int a, int b)
// // // // // // // // {
// // // // // // // //     for(int i = (a-1);i>0;i++)//向前判断
// // // // // // // //     {
// // // // // // // //         if(zu[i][b]=='X')//如果碰到墙壁了说明这列可以放置
// // // // // // // //         {
// // // // // // // //             break;
// // // // // // // //         }
// // // // // // // //         if (zu[i][b]='+')//如果碰到炮台说明不可以放置
// // // // // // // //         {
// // // // // // // //             return 0;
// // // // // // // //         }
// // // // // // // //     }
// // // // // // // //     for(int i = (b-1);i>0;i++)//向前判断
// // // // // // // //     {
// // // // // // // //         if(zu[a][i]=='X')//如果碰到墙壁了说明这行可以放置
// // // // // // // //         {
// // // // // // // //             break;
// // // // // // // //         }
// // // // // // // //         if (zu[a][i]='+')//如果碰到炮台说明不可以放置
// // // // // // // //         {
// // // // // // // //             return 0;
// // // // // // // //         }
// // // // // // // //     }
// // // // // // // //     return 1;
// // // // // // // // }


// // // // // // // // int main()
// // // // // // // // {
// // // // // // // //     while(~scanf("%d",&k))
// // // // // // // //     {
// // // // // // // //         s=getchar();//清空缓存区的回车键
// // // // // // // //         jieshou(k);//输入网格
// // // // // // // //         paotai(0,0);//炮台放置
// // // // // // // //         printf("%d",maxsum);
// // // // // // // //         maxsum=0;
// // // // // // // //     }
// // // // // // // // }

// // // // // // // #include <stdio.h>
// // // // // // //     int k;
// // // // // // //     char zu[4][4];
// // // // // // //     int sum=0;
// // // // // // //     int maxsum=0;
// // // // // // //     char s;

// // // // // // // void jieshou(int k)//输入网格
// // // // // // // {
// // // // // // //     char l;
// // // // // // //     for(int i=0;i<k;i++)
// // // // // // //     {
// // // // // // //         for(int j=0;j<k;j++)
// // // // // // //         {
// // // // // // //             l=getchar();
// // // // // // //             zu[i][j]=l;
// // // // // // //         }
// // // // // // //         l=getchar();
// // // // // // //     }
// // // // // // // }


// // // // // // // // 放置炮台
// // // // // // // /*
// // // // // // // q:传入的是坐标，q经过 /k 和 %k 之后可以计算出对于的坐标x和坐标y
// // // // // // // sum传入的是当前棋盘中炮台的数量
// // // // // // // */

// // // // // // // void paotai(int q,int sum)
// // // // // // // {
// // // // // // //     int x = q / k;
// // // // // // //     int y = q % k;
// // // // // // //     if (q>k*k)
// // // // // // //     {
// // // // // // //         if (sum>=maxsum)
// // // // // // //         {
// // // // // // //             maxsum=sum;
// // // // // // //         }
// // // // // // //     }
// // // // // // //     else
// // // // // // //     {
// // // // // // //         if (zu[x][y]=='.' && hefa(x,y))
// // // // // // //             {
// // // // // // //                 zu[x][y]='+';//放置炮台
// // // // // // //                 paotai(q+1,sum+1);//炮台数量+1
// // // // // // //                 zu[x][y]='.';//还原
// // // // // // //             }
            
// // // // // // //         paotai(q+1,sum);//先写的应该是这行，传入q后面的一个位置
// // // // // // //     }
    
    
    
// // // // // // // }



// // // // // // // // 合法性判断
// // // // // // // /*
// // // // // // // 如果合法就返回1，不合法返回0
// // // // // // // */

// // // // // // // int hefa(int a,int b)
// // // // // // // {
// // // // // // //     for(int i = (a-1);i>0;i++)//向前判断
// // // // // // //     {
// // // // // // //         if(zu[i][b]=='X')//如果碰到墙壁了说明这列可以放置
// // // // // // //         {
// // // // // // //             break;
// // // // // // //         }
// // // // // // //         if (zu[i][b]='+')//如果碰到炮台说明不可以放置
// // // // // // //         {
// // // // // // //             return 0;
// // // // // // //         }
// // // // // // //     }
// // // // // // //     for(int i = (b-1);i>0;i++)//向前判断
// // // // // // //     {
// // // // // // //         if(zu[a][i]=='X')//如果碰到墙壁了说明这行可以放置
// // // // // // //         {
// // // // // // //             break;
// // // // // // //         }
// // // // // // //         if (zu[a][i]='+')//如果碰到炮台说明不可以放置
// // // // // // //         {
// // // // // // //             return 0;
// // // // // // //         }
// // // // // // //     }
// // // // // // //     return 1;
// // // // // // // }


// // // // // // // int main()
// // // // // // // {
// // // // // // //     while(~scanf("%d",&k))
// // // // // // //     {
// // // // // // //         s=getchar();//清空缓存区的回车键
// // // // // // //         jieshou(k);//输入网格
// // // // // // //         paotai(0,0);//炮台放置
// // // // // // //         printf("%d",maxsum);
// // // // // // //         maxsum=0;
// // // // // // //     }
// // // // // // // }




// // // // // // #include <stdio.h>
// // // // // //     int k;
// // // // // //     char zu[4][4];
// // // // // //     int sum=0;
// // // // // //     int maxsum=0;
// // // // // //     char s;

// // // // // // void jieshou(int k)//输入网格
// // // // // // {
// // // // // //     char l;
// // // // // //     for(int i=0;i<k;i++)
// // // // // //     {
// // // // // //         for(int j=0;j<k;j++)
// // // // // //         {
// // // // // //             l=getchar();
// // // // // //             zu[i][j]=l;
// // // // // //         }
// // // // // //         l=getchar();
// // // // // //     }
// // // // // // }

// // // // // // // 合法性判断
// // // // // // /*
// // // // // // 如果合法就返回1，不合法返回0
// // // // // // */

// // // // // // int panduan(int a,int b)
// // // // // // {
// // // // // //     for(int i = (a-1);i>=0;i--)//向前判断
// // // // // //     {
// // // // // //         if(zu[i][b]=='X')//如果碰到墙壁了说明这列可以放置
// // // // // //         {
// // // // // //             break;
// // // // // //         }
// // // // // //         if (zu[i][b]=='+')//如果碰到炮台说明不可以放置
// // // // // //         {
// // // // // //             return 0;
// // // // // //         }
// // // // // //     }
// // // // // //     for(int j = (b-1);j>=0;j--)//向前判断
// // // // // //     {
// // // // // //         if(zu[a][j]=='X')//如果碰到墙壁了说明这行可以放置
// // // // // //         {
// // // // // //             break;
// // // // // //         }
// // // // // //         if (zu[a][j]=='+')//如果碰到炮台说明不可以放置
// // // // // //         {
// // // // // //             return 0;
// // // // // //         }
// // // // // //     }
// // // // // //     return 1;
// // // // // // }

// // // // // // // 放置炮台
// // // // // // /*
// // // // // // q:传入的是坐标，q经过 /k 和 %k 之后可以计算出对于的坐标x和坐标y
// // // // // // sum传入的是当前棋盘中炮台的数量
// // // // // // */

// // // // // // void paotai(int q,int sum)
// // // // // // {
// // // // // //     int x = q / k;
// // // // // //     int y = q % k;

// // // // // //     if (q>=k*k)
// // // // // //     {
// // // // // //         if (sum>=maxsum)
// // // // // //         {
// // // // // //             maxsum=sum;
// // // // // //         }
// // // // // //     }
// // // // // //     else
// // // // // //     {
// // // // // //         if (zu[x][y]=='.')
// // // // // //             {
// // // // // //                 if(panduan(x,y))
// // // // // //                 {
// // // // // //                     zu[x][y]='+';//放置炮台
// // // // // //                     paotai(q+1,sum+1);//炮台数量+1
// // // // // //                     zu[x][y]='.';//还原
// // // // // //                 }
// // // // // //             }
// // // // // //         paotai(q+1,sum);//先写的应该是这行，传入q后面的一个位置
// // // // // //     }
// // // // // // }


// // // // // // int main()
// // // // // // {
// // // // // //     while(~scanf("%d",&k))
// // // // // //     {
// // // // // //         s=getchar();//清空缓存区的回车键
// // // // // //         jieshou(k);//输入网格
// // // // // //         paotai(0,0);//炮台放置
// // // // // //         printf("%d",maxsum);
// // // // // //         maxsum=0;
// // // // // //     }
// // // // // //     return 0;
// // // // // // }

// // // // // #include <stdio.h>
// // // // // struct A
// // // // // {
// // // // //     char c;
// // // // //     char a;
// // // // //     int b;
    
// // // // // };

// // // // // int main()
// // // // // {
// // // // //     struct A aa;
// // // // //     printf("%d",sizeof(aa));
// // // // //     return 0;
// // // // // }




// // // // #include <stdio.h>

// // // // int f(int n)
// // // // {
// // // //     if (n==1)
// // // //     {
// // // //         return 1;
// // // //     }
// // // //     else 
// // // //     {
// // // //         return f(n-1)+n;
// // // //     }
// // // // }


// // // // int main()
// // // // {
// // // //     int n,c;
// // // //     scanf("%d",&n);
// // // //     c=f(n);
// // // //     printf("%d",c);
// // // //     return 0;
// // // // }



// // // #include<stdio.h>
// // // void solve()
// // // {
// // //     for (int i = 200; i < 3000; i++)
// // //     {
// // //         if (i<1000)
// // //         {
// // //             if ((i/100)==(i%10))
// // //             {
// // //                 printf("%d",i);
// // //             }
            
// // //         }
// // //         else
// // //         {
// // //             if ((i/1000)==(i%10))
// // //             {
// // //                 if (((i-(i/1000)*1000)/100)==(i/10)%10)
// // //                 {
// // //                     printf("%d",i);
// // //                 }
// // //             }
            
// // //         }
// // //     }
    

// // // }
// // // int main(void)
// // // {  
// // //     solve();
// // //    return 0;
// // // }
// // #include <stdio.h>
// // void Reverse(int n)
// // {
// // 	/**********   Begin   **********/
// //     if(n!=0)
// //     {
// //         printf("%d",n%10);
// //         Reverse(n/10);
// //     }
// // 	/**********   End   **********/
// // }
// // int main ()
// // {
// //     int n=0;
// //     scanf("%d",&n);
// //     Reverse(n);
// //     return 0;
// // }


// #include <stdio.h>
// int main()
// {
//     int a, b;
//     scanf("%d%d",&a,&b);
//     printf("%d",a/b);
// }


// #include <stdio.h>
// double f(int n)
// {
//     if (n<=2)  
//     {
//         return 1;
//     }
//     else
//     {
//         return f(n-1)+f(n-2);
//     }
// }


// int main()
// {
//     for (int i = 0; i < 100; i++)
//     {
//         printf("%d:%.0lf    ",i,f(i));
//     }
//     return 0 ;
// }




// #include <stdio.h>
// double f(int n)
// {
//     if (n==1)
//     {
//         return 2;
//     }
//     else
//     {
//         return f(n-1)*2;
//     }
// }


// int main()
// {
//     for (int i = 0; i < 10; i++)
//     {
//         printf("%d:%.0lf    ",i,f(i));
//     }

//     return 0 ;
// }



#include <stdio.h>
int main()
{
    int s=5;
    for (int i = 1; i < s+1; i++)
    {

        for (int k = 1; k <=s-i; k++)
        {
            // printf(" ");
        }
        for (int j = 1; j <= i; j++)
        {
            printf("%d",j);
        }
        for (int j = i-1; j > 0; j--)
        {
            printf("%d",j);
        }
        printf("\n");
        
    }
    return 0;
}

